home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / lib / python2.6 / xml / dom / pulldom.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  12.8 KB  |  439 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import xml.sax as xml
  5. import xml.sax.handler as xml
  6. import types
  7.  
  8. try:
  9.     _StringTypes = [
  10.         types.StringType,
  11.         types.UnicodeType]
  12. except AttributeError:
  13.     _StringTypes = [
  14.         types.StringType]
  15.  
  16. START_ELEMENT = 'START_ELEMENT'
  17. END_ELEMENT = 'END_ELEMENT'
  18. COMMENT = 'COMMENT'
  19. START_DOCUMENT = 'START_DOCUMENT'
  20. END_DOCUMENT = 'END_DOCUMENT'
  21. PROCESSING_INSTRUCTION = 'PROCESSING_INSTRUCTION'
  22. IGNORABLE_WHITESPACE = 'IGNORABLE_WHITESPACE'
  23. CHARACTERS = 'CHARACTERS'
  24.  
  25. class PullDOM(xml.sax.ContentHandler):
  26.     _locator = None
  27.     document = None
  28.     
  29.     def __init__(self, documentFactory = None):
  30.         XML_NAMESPACE = XML_NAMESPACE
  31.         import xml.dom
  32.         self.documentFactory = documentFactory
  33.         self.firstEvent = [
  34.             None,
  35.             None]
  36.         self.lastEvent = self.firstEvent
  37.         self.elementStack = []
  38.         self.push = self.elementStack.append
  39.         
  40.         try:
  41.             self.pop = self.elementStack.pop
  42.         except AttributeError:
  43.             pass
  44.  
  45.         self._ns_contexts = [
  46.             {
  47.                 XML_NAMESPACE: 'xml' }]
  48.         self._current_context = self._ns_contexts[-1]
  49.         self.pending_events = []
  50.  
  51.     
  52.     def pop(self):
  53.         result = self.elementStack[-1]
  54.         del self.elementStack[-1]
  55.         return result
  56.  
  57.     
  58.     def setDocumentLocator(self, locator):
  59.         self._locator = locator
  60.  
  61.     
  62.     def startPrefixMapping(self, prefix, uri):
  63.         if not hasattr(self, '_xmlns_attrs'):
  64.             self._xmlns_attrs = []
  65.         
  66.         if not prefix:
  67.             pass
  68.         self._xmlns_attrs.append(('xmlns', uri))
  69.         self._ns_contexts.append(self._current_context.copy())
  70.         if not prefix:
  71.             pass
  72.         self._current_context[uri] = None
  73.  
  74.     
  75.     def endPrefixMapping(self, prefix):
  76.         self._current_context = self._ns_contexts.pop()
  77.  
  78.     
  79.     def startElementNS(self, name, tagName, attrs):
  80.         xmlns_uri = 'http://www.w3.org/2000/xmlns/'
  81.         xmlns_attrs = getattr(self, '_xmlns_attrs', None)
  82.         if xmlns_attrs is not None:
  83.             for aname, value in xmlns_attrs:
  84.                 attrs._attrs[(xmlns_uri, aname)] = value
  85.             
  86.             self._xmlns_attrs = []
  87.         
  88.         (uri, localname) = name
  89.         if uri:
  90.             if tagName is None:
  91.                 prefix = self._current_context[uri]
  92.                 if prefix:
  93.                     tagName = prefix + ':' + localname
  94.                 else:
  95.                     tagName = localname
  96.             
  97.             if self.document:
  98.                 node = self.document.createElementNS(uri, tagName)
  99.             else:
  100.                 node = self.buildDocument(uri, tagName)
  101.         elif self.document:
  102.             node = self.document.createElement(localname)
  103.         else:
  104.             node = self.buildDocument(None, localname)
  105.         for aname, value in attrs.items():
  106.             (a_uri, a_localname) = aname
  107.             if a_uri == xmlns_uri:
  108.                 if a_localname == 'xmlns':
  109.                     qname = a_localname
  110.                 else:
  111.                     qname = 'xmlns:' + a_localname
  112.                 attr = self.document.createAttributeNS(a_uri, qname)
  113.                 node.setAttributeNodeNS(attr)
  114.             elif a_uri:
  115.                 prefix = self._current_context[a_uri]
  116.                 if prefix:
  117.                     qname = prefix + ':' + a_localname
  118.                 else:
  119.                     qname = a_localname
  120.                 attr = self.document.createAttributeNS(a_uri, qname)
  121.                 node.setAttributeNodeNS(attr)
  122.             else:
  123.                 attr = self.document.createAttribute(a_localname)
  124.                 node.setAttributeNode(attr)
  125.             attr.value = value
  126.         
  127.         self.lastEvent[1] = [
  128.             (START_ELEMENT, node),
  129.             None]
  130.         self.lastEvent = self.lastEvent[1]
  131.         self.push(node)
  132.  
  133.     
  134.     def endElementNS(self, name, tagName):
  135.         self.lastEvent[1] = [
  136.             (END_ELEMENT, self.pop()),
  137.             None]
  138.         self.lastEvent = self.lastEvent[1]
  139.  
  140.     
  141.     def startElement(self, name, attrs):
  142.         if self.document:
  143.             node = self.document.createElement(name)
  144.         else:
  145.             node = self.buildDocument(None, name)
  146.         for aname, value in attrs.items():
  147.             attr = self.document.createAttribute(aname)
  148.             attr.value = value
  149.             node.setAttributeNode(attr)
  150.         
  151.         self.lastEvent[1] = [
  152.             (START_ELEMENT, node),
  153.             None]
  154.         self.lastEvent = self.lastEvent[1]
  155.         self.push(node)
  156.  
  157.     
  158.     def endElement(self, name):
  159.         self.lastEvent[1] = [
  160.             (END_ELEMENT, self.pop()),
  161.             None]
  162.         self.lastEvent = self.lastEvent[1]
  163.  
  164.     
  165.     def comment(self, s):
  166.         if self.document:
  167.             node = self.document.createComment(s)
  168.             self.lastEvent[1] = [
  169.                 (COMMENT, node),
  170.                 None]
  171.             self.lastEvent = self.lastEvent[1]
  172.         else:
  173.             event = [
  174.                 (COMMENT, s),
  175.                 None]
  176.             self.pending_events.append(event)
  177.  
  178.     
  179.     def processingInstruction(self, target, data):
  180.         if self.document:
  181.             node = self.document.createProcessingInstruction(target, data)
  182.             self.lastEvent[1] = [
  183.                 (PROCESSING_INSTRUCTION, node),
  184.                 None]
  185.             self.lastEvent = self.lastEvent[1]
  186.         else:
  187.             event = [
  188.                 (PROCESSING_INSTRUCTION, target, data),
  189.                 None]
  190.             self.pending_events.append(event)
  191.  
  192.     
  193.     def ignorableWhitespace(self, chars):
  194.         node = self.document.createTextNode(chars)
  195.         self.lastEvent[1] = [
  196.             (IGNORABLE_WHITESPACE, node),
  197.             None]
  198.         self.lastEvent = self.lastEvent[1]
  199.  
  200.     
  201.     def characters(self, chars):
  202.         node = self.document.createTextNode(chars)
  203.         self.lastEvent[1] = [
  204.             (CHARACTERS, node),
  205.             None]
  206.         self.lastEvent = self.lastEvent[1]
  207.  
  208.     
  209.     def startDocument(self):
  210.         if self.documentFactory is None:
  211.             import xml.dom.minidom as xml
  212.             self.documentFactory = xml.dom.minidom.Document.implementation
  213.         
  214.  
  215.     
  216.     def buildDocument(self, uri, tagname):
  217.         node = self.documentFactory.createDocument(uri, tagname, None)
  218.         self.document = node
  219.         self.lastEvent[1] = [
  220.             (START_DOCUMENT, node),
  221.             None]
  222.         self.lastEvent = self.lastEvent[1]
  223.         self.push(node)
  224.         for e in self.pending_events:
  225.             if e[0][0] == PROCESSING_INSTRUCTION:
  226.                 (_, target, data) = e[0]
  227.                 n = self.document.createProcessingInstruction(target, data)
  228.                 e[0] = (PROCESSING_INSTRUCTION, n)
  229.             elif e[0][0] == COMMENT:
  230.                 n = self.document.createComment(e[0][1])
  231.                 e[0] = (COMMENT, n)
  232.             else:
  233.                 raise AssertionError('Unknown pending event ', e[0][0])
  234.             self.lastEvent[1] = e[0][0] == PROCESSING_INSTRUCTION
  235.             self.lastEvent = e
  236.         
  237.         self.pending_events = None
  238.         return node.firstChild
  239.  
  240.     
  241.     def endDocument(self):
  242.         self.lastEvent[1] = [
  243.             (END_DOCUMENT, self.document),
  244.             None]
  245.         self.pop()
  246.  
  247.     
  248.     def clear(self):
  249.         '''clear(): Explicitly release parsing structures'''
  250.         self.document = None
  251.  
  252.  
  253.  
  254. class ErrorHandler:
  255.     
  256.     def warning(self, exception):
  257.         print exception
  258.  
  259.     
  260.     def error(self, exception):
  261.         raise exception
  262.  
  263.     
  264.     def fatalError(self, exception):
  265.         raise exception
  266.  
  267.  
  268.  
  269. class DOMEventStream:
  270.     
  271.     def __init__(self, stream, parser, bufsize):
  272.         self.stream = stream
  273.         self.parser = parser
  274.         self.bufsize = bufsize
  275.         if not hasattr(self.parser, 'feed'):
  276.             self.getEvent = self._slurp
  277.         
  278.         self.reset()
  279.  
  280.     
  281.     def reset(self):
  282.         self.pulldom = PullDOM()
  283.         self.parser.setFeature(xml.sax.handler.feature_namespaces, 1)
  284.         self.parser.setContentHandler(self.pulldom)
  285.  
  286.     
  287.     def __getitem__(self, pos):
  288.         rc = self.getEvent()
  289.         if rc:
  290.             return rc
  291.         raise IndexError
  292.  
  293.     
  294.     def next(self):
  295.         rc = self.getEvent()
  296.         if rc:
  297.             return rc
  298.         raise StopIteration
  299.  
  300.     
  301.     def __iter__(self):
  302.         return self
  303.  
  304.     
  305.     def expandNode(self, node):
  306.         event = self.getEvent()
  307.         parents = [
  308.             node]
  309.         while event:
  310.             (token, cur_node) = event
  311.             if cur_node is node:
  312.                 return None
  313.             if token != END_ELEMENT:
  314.                 parents[-1].appendChild(cur_node)
  315.             
  316.             if token == START_ELEMENT:
  317.                 parents.append(cur_node)
  318.             elif token == END_ELEMENT:
  319.                 del parents[-1]
  320.             
  321.             event = self.getEvent()
  322.  
  323.     
  324.     def getEvent(self):
  325.         if not self.pulldom.firstEvent[1]:
  326.             self.pulldom.lastEvent = self.pulldom.firstEvent
  327.         
  328.         while not self.pulldom.firstEvent[1]:
  329.             buf = self.stream.read(self.bufsize)
  330.             if not buf:
  331.                 self.parser.close()
  332.                 return None
  333.             self.parser.feed(buf)
  334.             continue
  335.             buf
  336.         rc = self.pulldom.firstEvent[1][0]
  337.         self.pulldom.firstEvent[1] = self.pulldom.firstEvent[1][1]
  338.         return rc
  339.  
  340.     
  341.     def _slurp(self):
  342.         ''' Fallback replacement for getEvent() using the
  343.             standard SAX2 interface, which means we slurp the
  344.             SAX events into memory (no performance gain, but
  345.             we are compatible to all SAX parsers).
  346.         '''
  347.         self.parser.parse(self.stream)
  348.         self.getEvent = self._emit
  349.         return self._emit()
  350.  
  351.     
  352.     def _emit(self):
  353.         ''' Fallback replacement for getEvent() that emits
  354.             the events that _slurp() read previously.
  355.         '''
  356.         rc = self.pulldom.firstEvent[1][0]
  357.         self.pulldom.firstEvent[1] = self.pulldom.firstEvent[1][1]
  358.         return rc
  359.  
  360.     
  361.     def clear(self):
  362.         '''clear(): Explicitly release parsing objects'''
  363.         self.pulldom.clear()
  364.         del self.pulldom
  365.         self.parser = None
  366.         self.stream = None
  367.  
  368.  
  369.  
  370. class SAX2DOM(PullDOM):
  371.     
  372.     def startElementNS(self, name, tagName, attrs):
  373.         PullDOM.startElementNS(self, name, tagName, attrs)
  374.         curNode = self.elementStack[-1]
  375.         parentNode = self.elementStack[-2]
  376.         parentNode.appendChild(curNode)
  377.  
  378.     
  379.     def startElement(self, name, attrs):
  380.         PullDOM.startElement(self, name, attrs)
  381.         curNode = self.elementStack[-1]
  382.         parentNode = self.elementStack[-2]
  383.         parentNode.appendChild(curNode)
  384.  
  385.     
  386.     def processingInstruction(self, target, data):
  387.         PullDOM.processingInstruction(self, target, data)
  388.         node = self.lastEvent[0][1]
  389.         parentNode = self.elementStack[-1]
  390.         parentNode.appendChild(node)
  391.  
  392.     
  393.     def ignorableWhitespace(self, chars):
  394.         PullDOM.ignorableWhitespace(self, chars)
  395.         node = self.lastEvent[0][1]
  396.         parentNode = self.elementStack[-1]
  397.         parentNode.appendChild(node)
  398.  
  399.     
  400.     def characters(self, chars):
  401.         PullDOM.characters(self, chars)
  402.         node = self.lastEvent[0][1]
  403.         parentNode = self.elementStack[-1]
  404.         parentNode.appendChild(node)
  405.  
  406.  
  407. default_bufsize = 16364
  408.  
  409. def parse(stream_or_string, parser = None, bufsize = None):
  410.     if bufsize is None:
  411.         bufsize = default_bufsize
  412.     
  413.     if type(stream_or_string) in _StringTypes:
  414.         stream = open(stream_or_string)
  415.     else:
  416.         stream = stream_or_string
  417.     if not parser:
  418.         parser = xml.sax.make_parser()
  419.     
  420.     return DOMEventStream(stream, parser, bufsize)
  421.  
  422.  
  423. def parseString(string, parser = None):
  424.     
  425.     try:
  426.         StringIO = StringIO
  427.         import cStringIO
  428.     except ImportError:
  429.         StringIO = StringIO
  430.         import StringIO
  431.  
  432.     bufsize = len(string)
  433.     buf = StringIO(string)
  434.     if not parser:
  435.         parser = xml.sax.make_parser()
  436.     
  437.     return DOMEventStream(buf, parser, bufsize)
  438.  
  439.